home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / FusionIcon / util.py < prev   
Encoding:
Python Source  |  2008-11-09  |  10.9 KB  |  421 lines
  1. # This file is part of Fusion-icon.
  2.  
  3. # Fusion-icon is free software; you can redistribute it and/or modify
  4. # it under the terms of the GNU General Public License as published by
  5. # the Free Software Foundation; either version 2 of the License, or
  6. # (at your option) any later version.
  7. #
  8. # Fusion-icon is distributed in the hope that it will be useful,
  9. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. # GNU General Public License for more details.
  12. #
  13. # You should have received a copy of the GNU General Public License
  14. # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15. #
  16. # Based on compiz-icon, Copyright 2007 Felix Bellanger <keeguon@gmail.com>
  17. #
  18. # Author(s): crdlb
  19. # Copyright 2007 Christopher Williams <christopherw@verizon.net> 
  20.  
  21. import os, compizconfig, ConfigParser, time
  22. import data as _data
  23. from parser import options as parser_options
  24. from environment import env
  25. from execute import run
  26. import subprocess, signal
  27.  
  28. def is_running(app):
  29.     'Use pgrep to determine if an app is running'
  30.  
  31.     if run(['pgrep', app], 'call', quiet=True) == 0:
  32.         return True
  33.  
  34.  
  35. class Application(object):
  36.  
  37.     def __init__(self, name, apps, installed):
  38.  
  39.         self.name = name
  40.         self.apps = apps
  41.  
  42.         self.base = installed.apps[name][0]
  43.         self.command = installed.apps[name][1]
  44.         self.label = installed.apps[name][2]
  45.  
  46.     def launch(self):
  47.         print ' * Launching %s' %self.label
  48.         run(self.command)
  49.  
  50. class Applications(dict):
  51.  
  52.     def __init__(self, installed):
  53.         for app in installed.apps:
  54.             self[app] = Application(app, self, installed)
  55.  
  56. class CompizOption(object):
  57.  
  58.     def __init__(self, name, options, installed, config):
  59.  
  60.         self.options = options
  61.         self.config = config
  62.  
  63.         self.name = name
  64.         self.switch = installed.options[name][1]
  65.         self.label = installed.options[name][2]
  66.         self.sensitive = True
  67.  
  68.     def __get(self):
  69.         return self.config.getboolean('compiz options', self.name)
  70.  
  71.     def __set(self, value):
  72.         print ' * Setting option %s to %s' %(self.label, value)
  73.         self.config.set('compiz options', self.name, str(bool(value)).lower())
  74.         self.config.write(open(self.config.config_file, 'w'))
  75.  
  76.     enabled = property(__get, __set)
  77.  
  78. class CompizOptions(dict):
  79.  
  80.     def __init__(self, installed, config):
  81.         for option in installed.options:
  82.             self[option] = CompizOption(option, self, installed, config)
  83.  
  84. class WindowManager(object):
  85.  
  86.     def __init__(self, name, wms, installed):
  87.  
  88.         self.wms = wms
  89.         self.name = name
  90.         self.base = installed.wms[name][0]
  91.         self.command = installed.wms[name][1]
  92.         self.label = installed.wms[name][2]
  93.         self.desktop = installed.wms[name][3]
  94.         if installed.wms[name][4]:
  95.             self.flags = installed.wms[name][4]
  96.         else:
  97.             self.flags = []
  98.         self.killcmd = installed.wms[name][5]
  99.  
  100. class WindowManagers(dict):
  101.  
  102.     def __init__(self, installed, config):
  103.  
  104.         self.config = config
  105.  
  106.         for wm in installed.wms:
  107.             self[wm] = WindowManager(wm, self, installed)
  108.  
  109.         self.fallback = None
  110.         wm = [w for w in self if self[w].desktop == env.desktop]
  111.         if wm:
  112.             self.fallback = wm[0]
  113.  
  114.         elif [w for w in self if w != 'compiz']:
  115.             self.fallback = list([w for w in self if w != 'compiz'])[0]
  116.  
  117.         self.__set_old()
  118.  
  119.         self.ordered_list = []
  120.         for wm in ('compiz', self.fallback):
  121.             if wm in self:
  122.                 self.ordered_list.append(wm)
  123.         self.ordered_list.extend([wm for wm in self if wm not in self.ordered_list])
  124.     
  125.     def __get(self):
  126.         return self.config.get('window manager', 'active wm')
  127.  
  128.     def __set(self, value):
  129.  
  130.         if value in wms:
  131.             print ' * Setting window manager to', wms[value].label
  132.         elif not value:
  133.             print ' * Setting window manager to empty value'
  134.  
  135.         self.config.set('window manager', 'active wm', str(value))
  136.         self.config.write(open(self.config.config_file, 'w'))
  137.  
  138.     def __set_old(self):
  139.         
  140.         self.old = None
  141.         running_wm = [wm for wm in self if is_running(wm)]
  142.         if running_wm:
  143.             # not perfect, but good enough
  144.             self.old = running_wm[0]
  145.  
  146.     def start(self):
  147.         'Start the active window manager'
  148.         
  149.         self.__set_old()
  150.  
  151.         if self.active == 'compiz' and self.old and self[self.old].killcmd:
  152.             if run(['which', self[self.old].killcmd[0]], 'call', quiet=True) == 0:
  153.                 run(self[self.old].killcmd, 'call')
  154.                 time.sleep(1)
  155.  
  156.         if self.active and self.old and 'noreplace' in self[self.active].flags:
  157.             run(['killall', self[self.old].base], 'call')
  158.             time.sleep(1)
  159.  
  160.         if self.active == 'compiz':
  161.             # use a copy, not the original
  162.             compiz_command = self['compiz'].command[:]
  163.             for option in options:
  164.                 if options[option].enabled:
  165.                     compiz_command.append(options[option].switch)    
  166.  
  167.             kill_list = ['killall']
  168.             for decorator in decorators:
  169.                 kill_list.append(decorators[decorator].base)
  170.             run(kill_list, 'call')
  171.             
  172.             time.sleep(0.5)
  173.  
  174.             # do it
  175.             print ' ... executing:', ' '.join(compiz_command)
  176.             run(compiz_command, quiet=False)
  177.  
  178.         elif self.active:
  179.             run(self[self.active].command)
  180.  
  181.         else:
  182.             print ' * No active WM set; not going to do anything.'
  183.  
  184.     def restart(self):
  185.         if wms.active:
  186.             print ' * Reloading %s' %wms.active
  187.             self.start()
  188.  
  189.         else:
  190.             print ' * Not reloading, no active window manager set'
  191.  
  192.     active = property(__get, __set)
  193.  
  194. class CompizDecorator(object):
  195.  
  196.     def __init__(self, name, decorators, installed):
  197.  
  198.         self.decorators = decorators
  199.         self.name = name
  200.         self.base = installed.decorators[name][0]
  201.         self.command = installed.decorators[name][1]
  202.         self.label = installed.decorators[name][2]
  203.         self.desktop = installed.decorators[name][3]
  204.  
  205.     def kill_others(self):
  206.         killall = ['killall']
  207.         for decorator in [x for x in self.decorators if x != self.name]:
  208.             killall.append(self.decorators[decorator].base)
  209.         run(killall, 'call')
  210.  
  211. class CompizDecorators(dict):
  212.         
  213.     def __init__(self, installed):
  214.  
  215.         # Open CompizConfig context
  216.         if parser_options.verbose:
  217.             print ' * Opening CompizConfig context'
  218.  
  219.         try:
  220.             context = compizconfig.Context( \
  221.                 plugins=['decoration'], basic_metadata=True)
  222.  
  223.         except:
  224.             context = compizconfig.Context()
  225.  
  226.         self.command = context.Plugins['decoration'].Display['command']
  227.  
  228.         for decorator in installed.decorators:
  229.             self[decorator] = CompizDecorator(decorator, self, installed)
  230.  
  231.         self.default = None
  232.         decorator = [d for d in self if self[d].desktop == env.desktop]
  233.         if decorator:
  234.             self.default = decorator[0]
  235.  
  236.         elif 'emerald' in self:
  237.             self.default = 'emerald'
  238.  
  239.         elif self:                       
  240.             self.default = self.keys()[0]
  241.     
  242.     def __set(self, decorator):
  243.         if decorator in self:
  244.             self.command.Plugin.Context.ProcessEvents()
  245.             print ' * Setting decorator to %s ("%s")' \
  246.                 %(self[decorator].label, self[decorator].command)
  247.             self.command.Value = self[decorator].command
  248.             self.command.Plugin.Context.Write()
  249.         elif not decorator:
  250.             print ' * Not setting decorator to none'
  251.  
  252.     def __get(self):
  253.         _decorator = [d for d in self if self.command.Value == self[d].command]
  254.         if _decorator:
  255.             decorator = _decorator[0]
  256.         else:
  257.             print ' * Decorator "%s" is invalid.' %self.command.Value
  258.             self.active = self.default
  259.             decorator = self.command.Value
  260.         return decorator
  261.  
  262.     active = property(__get, __set)
  263.  
  264. class Installed(object):
  265.  
  266.     def __init__(self, data):
  267.         print ' * Searching for installed applications...'
  268.  
  269.         ### Compiz Detection
  270.         bins = {}
  271.         for name in ('compiz', 'compiz.real'):
  272.             bin = run(['which', name], 'output')
  273.             if bin:
  274.                 bins[name] = bin
  275.  
  276.         if 'compiz' in bins and 'compiz.real' in bins:
  277.             if bins['compiz'].split(os.sep)[:-1] == bins['compiz.real'].split(os.sep)[:-1]:
  278.                 compiz = 'compiz.real'
  279.             else:
  280.                 compiz = 'compiz'
  281.  
  282.         elif 'compiz.real' in bins:
  283.             compiz = 'compiz.real'
  284.  
  285.         elif 'compiz' in bins:
  286.             compiz = 'compiz'
  287.  
  288.         else:
  289.             compiz = None
  290.  
  291.         output = ''
  292.  
  293.         for name in bins:
  294.             if len(bins) > 1 and name == compiz:
  295.                 selected = ' <*>'
  296.             else:
  297.                 selected = ''
  298.             output += ' -- %s%s' %(bins[name], selected)
  299.  
  300.         ### Everything Else
  301.         self.wms = data.wms.copy()
  302.         for wm in data.wms:
  303.             which = run(['which', data.wms[wm][0]], 'output')
  304.             if which:
  305.                 output += ' -- %s' %which
  306.             else:
  307.                 del self.wms[wm]
  308.  
  309.         if compiz:
  310.             data.compiz_args.insert(0, compiz)
  311.             self.wms['compiz'] = (compiz, data.compiz_args, 'Compiz', None, None, None)
  312.  
  313.         self.decorators = data.decorators.copy()
  314.         for decorator in data.decorators:
  315.             which = run(['which', data.decorators[decorator][0]], 'output')
  316.             if which:
  317.                 output += ' -- %s' %which
  318.             else:
  319.                 del self.decorators[decorator]
  320.  
  321.         self.apps = data.apps.copy()
  322.         for app in data.apps:
  323.             which = run(['which', data.apps[app][0]], 'output')
  324.             if which:
  325.                 output += ' -- %s' %which
  326.             else:
  327.                 del self.apps[app]
  328.  
  329.         if parser_options.verbose:
  330.             print output.rstrip()
  331.         
  332.         compiz_optionlist = []
  333.  
  334.         self.options = data.options.copy()
  335.  
  336.         if compiz:
  337.             compiz_help = run([compiz, '--help'], 'output')
  338.             for item in compiz_help.split():
  339.                 item = item[1:].replace(']', '')
  340.                 if item.startswith('--'):
  341.                     compiz_optionlist.append(item)
  342.  
  343.         for option in data.options:
  344.             if data.options[option][1] not in compiz_optionlist:
  345.                 del self.options[option]
  346.  
  347. class Configuration(ConfigParser.ConfigParser):
  348.  
  349.     def __init__(self, data):
  350.         
  351.         ConfigParser.ConfigParser.__init__(self)
  352.         self.config_folder = data.config_folder
  353.         self.config_file = data.config_file
  354.  
  355.     def check(self):
  356.  
  357.         # Configuration file setup
  358.         if not os.path.exists(self.config_folder):
  359.             if parser_options.verbose: 
  360.                 print ' * Creating configuration folder...'
  361.             os.makedirs(self.config_folder)
  362.  
  363.         if not os.path.exists(self.config_file):
  364.             if parser_options.verbose:
  365.                 print ' * Creating configuration file...'
  366.             self.create_config_file()
  367.  
  368.         try:
  369.             # Read the file
  370.             self.read(self.config_file)
  371.             # Validate the file by trying to read all values
  372.             for option in options:
  373.                 value = options[option].enabled
  374.             value = wms.active
  375.  
  376.         except:
  377.             # back it up and make a new one
  378.             print ' * Configuration file (%s) invalid' %self.config_file
  379.             self.reset_config_file()
  380.             print ' * Generating new configuration file'
  381.             self.create_config_file()
  382.  
  383.     def create_config_file(self):
  384.         'Set default values for configuration file'
  385.  
  386.         def prune(section, optlist):
  387.             for option in [o for o in self.options(section) if o not in optlist]:
  388.                 self.remove_option(section, option)
  389.  
  390.         for section in ('compiz options', 'window manager'):
  391.             if not self.has_section(section):
  392.                 self.add_section(section)
  393.  
  394.         for option in options:
  395.             self.set('compiz options', option, 'false')
  396.         self.set('window manager', 'active wm', 'compiz')
  397.  
  398.         prune('compiz options', options)
  399.         prune('window manager', ['active wm'])
  400.         self.write(open(self.config_file, 'w'))
  401.  
  402.     def reset_config_file(self):
  403.         'Backup configuration file'
  404.  
  405.         if os.path.exists(self.config_file):
  406.             config_backup = '%s.backup.%s' \
  407.                 %(self.config_file, time.strftime('%Y%m%d%H%M%S'))
  408.             os.rename(self.config_file, config_backup)
  409.             print ' ... backed up to:', config_backup
  410.         else:
  411.             print ' ... no configuration file found'
  412.  
  413. # Instantiate...
  414. _installed = Installed(_data)
  415. config = Configuration(_data)
  416. apps = Applications(_installed)
  417. options = CompizOptions(_installed, config)
  418. wms = WindowManagers(_installed, config)
  419. decorators = CompizDecorators(_installed)
  420.  
  421.